编程范式游记（11）- 程序世界里的编程范式 [2026重制版]

// Go: 典型的命令式风格
func processUsers(users []User) []UserInfo {
    var result []UserInfo

    for i := 0; i < len(users); i++ {
        user := users[i]

        // 过滤条件
        if user.Age < 18 {
            continue
        }
        if !user.IsActive {
            continue
        }

        // 变换数据
        info := UserInfo{
            Name:     strings.ToUpper(user.Name),
            Email:    strings.ToLower(user.Email),
            AgeGroup: getAgeGroup(user.Age),
            Score:    calculateScore(user),
        }

        result = append(result, info)
    }

    return result
}

// Rust: 函数式迭代器链
fn process_users(users: &[User]) -> Vec<UserInfo> {
    users
        .iter()
        .filter(|u| u.age >= 18)           // filter
        .filter(|u| u.is_active)            // filter again
        .map(|u| {                          // map/transform
            UserInfo {
                name: u.name.to_uppercase(),
                email: u.email.to_lowercase(),
                age_group: age_group(u.age),
                score: calculate_score(u),
            }
        })
        .collect()                           // 收集为Vec
}

// TypeScript: OOP with Strategy Pattern
interface UserFilterStrategy {
    shouldInclude(user: User): boolean;
}

class AdultOnlyFilter implements UserFilterStrategy {
    shouldInclude(user: User): boolean {
        return user.age >= 18;
    }
}

class ActiveUserFilter implements UserFilterStrategy {
    shouldInclude(user: User): boolean {
        return user.isActive;
    }
}

class UserProcessor {
    private filters: UserFilterStrategy[] = [];
    private transformer: UserTransformer;

    addFilter(filter: UserFilterStrategy): void {
        this.filters.push(filter);
    }

    process(users: User[]): UserInfo[] {
        return users
            .filter(user => this.filters.every(f => f.shouldInclude(user)))
            .map(user => this.transformer.transform(user));
    }
}

// 使用
const processor = new UserProcessor();
processor.addFilter(new AdultOnlyFilter());
processor.addFilter(new ActiveUserFilter());
const results = processor.process(userList);

-- SQL: 最纯粹的声明式
SELECT
    UPPER(u.name) AS name,
    LOWER(u.email) AS email,
    CASE
        WHEN u.age BETWEEN 18 AND 30 THEN 'young'
        WHEN u.age BETWEEN 31 AND 50 THEN 'middle'
        ELSE 'senior'
    END AS age_group,
    (u.activity_score * u.engagement_rate) * 100 AS score
FROM users u
WHERE u.age >= 18
  AND u.is_active = TRUE
ORDER BY score DESC;

% Prolog/Datalog: 声明式规则
process_user(Name, Email, AgeGroup, Score) :-
    user(Name, _, Age, Email, IsActive, ActivityScore, EngagementRate),
    Age >= 18,
    IsActive = true,
    upper_case(Name, UpperName),
    lower_case(Email, LowerEmail),
    determine_age_group(Age, AgeGroup),
    Score is ActivityScore * EngagementRate * 100.

determine_age_group(Age, young) :- Age >= 18, Age =< 30.
determine_age_group(Age, middle) :- Age >= 31, Age =< 50.
determine_age_group(Age, senior) :- Age > 50.

?- process_user(N, E, AG, S).

过去 (2018):
┌─────────────────────────────────────┐
│ 开发者手写所有代码                    │
│ ├── Logic (业务逻辑)   ← 难以自动化  │
│ ├── Control (控制流程) ← 大量重复    │
│ └── Data (数据结构)   ← 相对固定    │
└─────────────────────────────────────┘

现在 (2026):
┌─────────────────────────────────────┐
│ 人机协作开发                         │
│ ├── Logic (业务逻辑)   ← 人类主导   │
│ ├── Control (控制流程) ← AI生成     │
│ │   (循环、错误处理、样板代码)       │
│ └── Data (数据结构)   ← AI建议      │
└─────────────────────────────────────┘

未来 (2030?):
┌─────────────────────────────────────┐
│ 自然语言驱动的开发                   │
│ ├── Intent (意图描述)  ← 人类输入   │
│ ├── Logic (自动推导)   ← AI理解    │
│ ├── Control (自动优化) ← AI生成    │
│ └── Verification (形式化证明) ← AI验证│
└─────────────────────────────────────┘